class AIAssistant:
    """AI助手父类，定义所有助手的基础属性和通用方法"""
    def __init__(self, aid, name, ass_type, version, is_online, ability_score):
        self.aid = aid  # 唯一ID（字符串类型，支持非纯数字ID）
        self.name = name  # 助手名称
        self.ass_type = ass_type  # 助手类型（需匹配子类类型）
        self.version = version  # 版本号
        self.is_online = is_online  # 是否在线（布尔值）
        self.ability_score = ability_score  # 能力评分（0-100）

    def start_service(self):
        """启动AI助手服务"""
        if self.is_online:
            return False, f"助手【{self.name}】已在运行。"
        self.is_online = True
        return True, f"✅ 助手【{self.name}】启动成功，当前状态：在线"

    def stop_service(self):
        """停止AI助手服务"""
        if not self.is_online:
            return False, f"助手【{self.name}】已处于离线状态。"
        self.is_online = False
        return True, f"✅ 助手【{self.name}】已停止，当前状态：离线"

    def assign_task(self, task_content):
        """为AI助手分配任务（需在线才能执行）"""
        if not self.is_online:
            return False, f"❌ {self.name} 当前离线，无法执行任务。"
        # 不同类型助手返回差异化任务结果
        task_result = self._generate_task_result(task_content)
        return True, f"✅ 任务分配成功！\n助手【{self.name}】响应：\n{task_result}"

    def _generate_task_result(self, task_content):
        """生成任务结果（子类可重写以实现类型专属逻辑）"""
        return f"已接收任务：{task_content}\n（基础助手通用处理完成）"

    def update_attribute(self, attr_name, new_value):
        """更新助手属性（基础属性通用更新逻辑）"""
        valid_attrs = {
            "name": str,
            "version": str,
            "is_online": lambda x: x in ["0", "1"],
            "ability_score": lambda x: x.isdigit() and 0 <= int(x) <= 100
        }

        # 验证属性合法性
        if attr_name not in valid_attrs:
            return False, f"无效属性！可修改属性为：{list(valid_attrs.keys())}"

        # 类型转换与验证
        try:
            if attr_name == "is_online":
                new_value = bool(int(new_value))
            elif attr_name == "ability_score":
                new_value = int(new_value)
            elif valid_attrs[attr_name] == str:
                new_value = str(new_value).strip()
        except Exception:
            return False, f"属性【{attr_name}】值格式错误！"

        # 更新属性
        setattr(self, attr_name, new_value)
        return True, f"✅ 属性【{attr_name}】已更新为：{new_value}"

    def to_string(self, detail=False):
        """生成助手信息字符串（detail=True时显示完整信息）"""
        status = "🟢在线" if self.is_online else "🔴离线"
        base_info = f"ID: {self.aid}, 名称: {self.name}, 类型: {self.ass_type}, " \
                    f"版本: {self.version}, 状态: {status}, 能力评分: {self.ability_score}"
        if detail:
            return f"{base_info} [详细类型: {self.ass_type}助手]"
        return base_info


# ------------------------------ 子类定义（5种专项AI助手）------------------------------
class DataAnalysisAssistant(AIAssistant):
    """数据分析助手（支持数据来源、分析维度属性）"""
    def __init__(self, aid, name, version, is_online, ability_score, data_sources=None, analysis_dims=None):
        super().__init__(aid, name, "数据分析", version, is_online, ability_score)
        self.data_sources = data_sources or ["Excel", "CSV"]  # 支持的数据来源
        self.analysis_dims = analysis_dims or ["趋势分析", "相关性分析"]  # 支持的分析维度

    def _generate_task_result(self, task_content):
        """重写任务处理逻辑：数据分析专属响应"""
        return f"📊 数据分析任务：{task_content}\n" \
               f"支持数据源：{', '.join(self.data_sources)}\n" \
               f"分析维度：{', '.join(self.analysis_dims)}\n" \
               f"（任务执行完成，已生成可视化报表）"

    def update_attribute(self, attr_name, new_value):
        """扩展支持子类专属属性更新"""
        sub_attrs = ["data_sources", "analysis_dims"]
        if attr_name in sub_attrs:
            # 格式：用逗号分隔多个值（如 "MySQL,JSON"）
            new_value = [v.strip() for v in new_value.split(",") if v.strip()]
            if not new_value:
                return False, f"属性【{attr_name}】不能为空！"
            setattr(self, attr_name, new_value)
            return True, f"✅ 子类属性【{attr_name}】已更新为：{new_value}"
        # 基础属性走父类逻辑
        return super().update_attribute(attr_name, new_value)

    def to_string(self, detail=False):
        base_str = super().to_string(detail)
        if detail:
            return f"{base_str}\n  专属配置：数据源={self.data_sources}, 分析维度={self.analysis_dims}"
        return base_str


class ImageGenerationAssistant(AIAssistant):
    """图片生成助手（支持分辨率、风格属性）"""
    def __init__(self, aid, name, version, is_online, ability_score, resolution=None, styles=None):
        super().__init__(aid, name, "图片生成", version, is_online, ability_score)
        self.resolution = resolution or "1024x768"  # 默认分辨率
        self.styles = styles or ["写实", "卡通", "抽象"]  # 支持的生成风格

    def _generate_task_result(self, task_content):
        """重写任务处理逻辑：图片生成专属响应"""
        return f"🖼️  图片生成任务：{task_content}\n" \
               f"生成分辨率：{self.resolution}\n" \
               f"支持风格：{', '.join(self.styles)}\n" \
               f"（图片生成完成，可下载高清版本）"


class TextGenerationAssistant(AIAssistant):
    """文本生成助手（支持文本类型、语言属性）"""
    def __init__(self, aid, name, version, is_online, ability_score, text_types=None, languages=None):
        super().__init__(aid, name, "文本生成", version, is_online, ability_score)
        self.text_types = text_types or ["文章", "诗歌", "代码"]  # 支持的文本类型
        self.languages = languages or ["中文", "英文"]  # 支持的语言

    def _generate_task_result(self, task_content):
        """重写任务处理逻辑：文本生成专属响应"""
        return f"📝 文本生成任务：{task_content}\n" \
               f"支持文本类型：{', '.join(self.text_types)}\n" \
               f"支持语言：{', '.join(self.languages)}\n" \
               f"（文本生成完成，字数统计：{len(task_content)*2}字）"


class TranslationAssistant(AIAssistant):
    """翻译助手（支持源语言、目标语言属性）"""
    def __init__(self, aid, name, version, is_online, ability_score, src_langs=None, tgt_langs=None):
        super().__init__(aid, name, "翻译", version, is_online, ability_score)
        self.src_langs = src_langs or ["中文", "英文"]  # 支持的源语言
        self.tgt_langs = tgt_langs or ["英文", "中文", "日语"]  # 支持的目标语言

    def _generate_task_result(self, task_content):
        """重写任务处理逻辑：翻译专属响应"""
        return f"🌐 翻译任务：{task_content}\n" \
               f"支持源语言：{', '.join(self.src_langs)}\n" \
               f"支持目标语言：{', '.join(self.tgt_langs)}\n" \
               f"（翻译完成，译文：{task_content} -> Translation Result）"


class VoiceAssistant(AIAssistant):
    """语音助手（支持语音格式、识别精度属性）"""
    def __init__(self, aid, name, version, is_online, ability_score, audio_formats=None, accuracy=None):
        super().__init__(aid, name, "语音", version, is_online, ability_score)
        self.audio_formats = audio_formats or ["MP3", "WAV"]  # 支持的音频格式
        self.accuracy = accuracy or 0.95  # 语音识别精度（默认95%）

    def _generate_task_result(self, task_content):
        """重写任务处理逻辑：语音专属响应"""
        return f"🎤 语音任务：{task_content}\n" \
               f"支持音频格式：{', '.join(self.audio_formats)}\n" \
               f"识别精度：{self.accuracy*100:.1f}%\n" \
               f"（语音处理完成，已生成文字转录稿）"


# ------------------------------ 管理类（核心控制逻辑）------------------------------
class AIManager:
    """AI助手管理器，负责助手的CRUD、服务控制、任务分配和统计"""
    def __init__(self, max_size=20):
        self.max_size = max_size  # 数组最大容量（文档要求固定大小）
        self.assistants = []  # 存储AI助手的数组
        # 初始化默认数据（文档示例数据）
        self._init_default_assistants()

    def _init_default_assistants(self):
        """初始化默认AI助手（文档示例中的5个助手）"""
        default_data = [
            # 语音助手（ID:101）
            VoiceAssistant(
                aid="101", name="小智", version="v1.2", is_online=True,
                ability_score=85, audio_formats=["MP3", "WAV"], accuracy=0.88
            ),
            # 文本生成助手（ID:102）
            TextGenerationAssistant(
                aid="102", name="文小助", version="v2.0", is_online=True,
                ability_score=92, text_types=["文章", "诗歌"], languages=["中文"]
            ),
            # 图片生成助手（ID:103）
            ImageGenerationAssistant(
                aid="103", name="图灵", version="v1.5", is_online=False,
                ability_score=88, resolution="1920x1080", styles=["写实", "水彩"]
            ),
            # 数据分析助手（ID:104）
            DataAnalysisAssistant(
                aid="104", name="数小析", version="v1.0", is_online=True,
                ability_score=79, data_sources=["Excel", "MySQL"], analysis_dims=["趋势", "聚类"]
            ),
            # 翻译助手（ID:105）
            TranslationAssistant(
                aid="105", name="翻译精灵", version="v2.1", is_online=False,
                ability_score=95, src_langs=["中", "英", "日"], tgt_langs=["中", "英", "韩"]
            )
        ]
        self.assistants.extend(default_data)

    def find_assistant_by_id(self, aid):
        """根据ID查找助手（返回助手对象或None）"""
        for ass in self.assistants:
            if ass.aid == str(aid):
                return ass
        return None

    def add_assistant(self):
        """添加新AI助手（控制台交互）"""
        # 检查容量
        if len(self.assistants) >= self.max_size:
            print("❌ 系统容量已满，无法添加新助手！")
            return

        # 基础信息输入
        aid = input("请输入ID: ").strip()
        # 检查ID唯一性
        if self.find_assistant_by_id(aid):
            print(f"❌ ID【{aid}】已存在，请重新输入！")
            return

        name = input("请输入名称: ").strip()
        if not name:
            print("❌ 名称不能为空！")
            return

        # 选择助手类型
        print("\n请选择助手类型（输入序号）：")
        type_mapping = {
            "1": ("数据分析", DataAnalysisAssistant),
            "2": ("图片生成", ImageGenerationAssistant),
            "3": ("文本生成", TextGenerationAssistant),
            "4": ("翻译", TranslationAssistant),
            "5": ("语音", VoiceAssistant)
        }
        for idx, (type_name, _) in type_mapping.items():
            print(f"  {idx}. {type_name}助手")

        type_choice = input("请输入类型序号: ").strip()
        if type_choice not in type_mapping:
            print("❌ 无效的类型选择！")
            return

        ass_type, ass_class = type_mapping[type_choice]

        # 其他基础属性
        version = input("请输入版本号: ").strip() or "v1.0"
        is_online = input("是否在线？(1-是, 0-否): ").strip()
        while is_online not in ["0", "1"]:
            is_online = input("❌ 输入错误！是否在线？(1-是, 0-否): ").strip()
        is_online = bool(int(is_online))

        # 能力评分（0-100）
        score_input = input("请输入能力评分(0-100): ").strip()
        while not (score_input.isdigit() and 0 <= int(score_input) <= 100):
            score_input = input("❌ 输入错误！请输入0-100的数字: ").strip()
        ability_score = int(score_input)

        # 创建子类实例（默认使用子类的默认专属属性）
        new_assistant = ass_class(
            aid=aid, name=name, version=version,
            is_online=is_online, ability_score=ability_score
        )

        # 添加到数组
        self.assistants.append(new_assistant)
        print(f"✅ 助手【{name}】添加成功！")

    def delete_assistant(self):
        """根据ID删除助手"""
        aid = input("请输入要删除的AI助手ID: ").strip()
        assistant = self.find_assistant_by_id(aid)
        if not assistant:
            print(f"❌ 未找到ID为【{aid}】的助手！")
            return

        self.assistants.remove(assistant)
        print(f"✅ 助手【{assistant.name}】已删除。")

    def update_assistant(self):
        """根据ID修改助手信息"""
        aid = input("请输入ID: ").strip()
        assistant = self.find_assistant_by_id(aid)
        if not assistant:
            print(f"❌ 未找到ID为【{aid}】的助手！")
            return

        # 显示可修改属性
        base_attrs = ["name", "version", "is_online", "ability_score"]
        # 子类专属属性（示例：仅列出部分）
        sub_attrs = []
        if isinstance(assistant, DataAnalysisAssistant):
            sub_attrs = ["data_sources", "analysis_dims"]
        elif isinstance(assistant, ImageGenerationAssistant):
            sub_attrs = ["resolution", "styles"]
        all_attrs = base_attrs + sub_attrs

        print(f"可修改属性列表为：{', '.join(all_attrs)}")
        input_str = input("请输入要修改的属性和值，用空格分割: ").strip()
        if len(input_str.split()) != 2:
            print("❌ 格式错误！正确格式：属性名 值")
            return

        attr_name, new_value = input_str.split(maxsplit=1)
        # 调用助手自身的更新方法
        success, msg = assistant.update_attribute(attr_name, new_value)
        print(msg)

    def start_assistant_service(self):
        """启动助手服务"""
        aid = input("请输入要启动的AI助手ID: ").strip()
        assistant = self.find_assistant_by_id(aid)
        if not assistant:
            print(f"❌ 未找到ID为【{aid}】的助手！")
            return

        success, msg = assistant.start_service()
        print(msg)

    def stop_assistant_service(self):
        """停止助手服务"""
        aid = input("请输入要停止的AI助手ID: ").strip()
        assistant = self.find_assistant_by_id(aid)
        if not assistant:
            print(f"❌ 未找到ID为【{aid}】的助手！")
            return

        success, msg = assistant.stop_service()
        print(msg)

    def assign_task_to_assistant(self):
        """为助手分配任务"""
        aid = input("请输入目标AI助手ID: ").strip()
        assistant = self.find_assistant_by_id(aid)
        if not assistant:
            print(f"❌ 未找到ID为【{aid}】的助手！")
            return

        task_content = input("请输入任务内容: ").strip()
        if not task_content:
            print("❌ 任务内容不能为空！")
            return

        success, msg = assistant.assign_task(task_content)
        print(msg)

    def show_all_assistants(self):
        """显示所有助手列表"""
        if not self.assistants:
            print("❌ 当前无任何AI助手！")
            return

        print("\n所有AI助手列表：")
        for idx, ass in enumerate(self.assistants, 1):
            print(f"{idx}. {ass.to_string(detail=True)}")

    def show_assistant_detail(self):
        """根据ID显示助手详情"""
        aid = input("请输入要查询的AI助手ID: ").strip()
        assistant = self.find_assistant_by_id(aid)
        if not assistant:
            print(f"❌ 未找到ID为【{aid}】的助手！")
            return

        print(f"\n✅ 查询结果: {assistant.to_string(detail=True)}")

    def show_system_statistics(self):
        """显示系统统计信息"""
        total = len(self.assistants)
        if total == 0:
            print("\n系统统计信息：")
            print("总助手数: 0")
            print("在线助手数: 0")
            print("离线助手数: 0")
            print("平均能力评分: 0.00")
            return

        # 计算在线数和平均评分
        online_count = sum(1 for ass in self.assistants if ass.is_online)
        offline_count = total - online_count
        avg_score = sum(ass.ability_score for ass in self.assistants) / total

        print("\n系统统计信息：")
        print(f"总助手数: {total}")
        print(f"在线助手数: {online_count}")
        print(f"离线助手数: {offline_count}")
        print(f"平均能力评分: {avg_score:.2f}")

    def run(self):
        """启动管理器（主循环）"""
        print("="*50)
        print("欢迎使用 AI助手管理器 v1.0")
        print("="*50)

        while True:
            # 显示菜单
            print("\n========== 🤖AI助手管理器 ==========")
            menu = [
                "1. 查看所有AI助手列表",
                "2. 根据ID查询助手详情",
                "3. 添加新的AI助手",
                "4. 根据ID修改助手信息",
                "5. 删除AI助手（按ID）",
                "6. 启动AI助手服务",
                "7. 停止AI助手服务",
                "8. 为AI助手分配任务",
                "9. 显示系统统计信息",
                "0. 退出系统"
            ]
            for item in menu:
                print(item)
            print("===================================")

            # 选择操作
            choice = input("请选择操作: ").strip()
            if choice == "0":
                print("👋 感谢使用，再见！")
                break

            # 执行对应操作
            action_map = {
                "1": self.show_all_assistants,
                "2": self.show_assistant_detail,
                "3": self.add_assistant,
                "4": self.update_assistant,
                "5": self.delete_assistant,
                "6": self.start_assistant_service,
                "7": self.stop_assistant_service,
                "8": self.assign_task_to_assistant,
                "9": self.show_system_statistics
            }

            if choice in action_map:
                action_map[choice]()
            else:
                print("❌ 无效的操作，请重新选择！")


# ------------------------------ 程序入口 ------------------------------
if __name__ == "__main__":
    manager = AIManager()
    manager.run()